#include "mainwindow.h"
#include "ui_mainwindow.h"

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    // 初始化系统
    Init();
}

MainWindow::~MainWindow()
{
    delete ui;
}


// 连接数据库
void MainWindow::ConnectSqlite()
{
    // 添加数据库驱动
    m_db = QSqlDatabase::addDatabase("QSQLITE");

    // 设置数据库
    m_db.setDatabaseName("data.db");

    // 打开数据库
    if(!m_db.open())
    {
        QMessageBox::critical(this, "", "连接数据库失败");
        close();
    }

    // 创建数据表
    QString str = QString("CREATE TABLE exam("
                                   "title TEXT PRIMARY KEY NOT NULL,"
                                   "res TEXT NOT NULL,"
                                   "score INTEGER NOT NULL,"
                                   "cate TEXT NOT NULL,"
                                   "item_a TEXT,"
                                   "item_b TEXT,"
                                   "item_c TEXT,"
                                   "item_d TEXT);"
                                   );

    QSqlQuery query;
    query.exec(str);
}


// 初始化系统
void MainWindow::Init()
{
    // 将界面切换到主页，索引为0的页面
    ui->stackedWidget->setCurrentIndex(0);

    // 设置控件风格
    SetStyleSheet();

    setFixedSize(this->width(),this->height());		// 禁止改变窗口大小。
    ui->rb_yn->setVisible(false);//设置名为 rb_yn 的控件不可见

    // 创建菜单
    CreateMenu();

    // 连接数据库
    ConnectSqlite();

    // 题目列表
    ShowList();

    // 作答动作
    Action();

    // 题目列表单击事件,用Lambda函数处理
    connect(ui->lst_q, &QListWidget::clicked, this, [=]()
    {
        //根据当前选择的题目索引 m_idx，定位到对应的题目，并设置界面上的相关文本和选项内容
        m_idx = ui->lst_q->currentRow();
        Question *p = m_arr[m_idx];

        ui->te_title->setText(p->m_title);
        ui->te_res->setText(p->m_res);
        ui->te_score->setText(QString::number(p->m_score));//number()函数实现整形转字符串

        //如果是单选题，则设置选项的文本和当前显示的页面索引为0
        //如果是多选题，则设置选项的文本和当前显示的页面索引为0
        //如果是其他类型的题目，则将当前显示的页面索引设置为1
        if(p->Cate() == "单选")
        {
            ChoiceSingle *c =  dynamic_cast<ChoiceSingle*>(p);
            ui->te_a->setText(c->m_a);
            ui->te_b->setText(c->m_b);
            ui->te_c->setText(c->m_c);
            ui->te_d->setText(c->m_d);
            ui->sw->setCurrentIndex(0);
        }
        else if(p->Cate() == "多选")
        {
            ChoiceMul *c =  dynamic_cast<ChoiceMul*>(p);
            ui->te_a->setText(c->m_a);
            ui->te_b->setText(c->m_b);
            ui->te_c->setText(c->m_c);
            ui->te_d->setText(c->m_d);
            ui->sw->setCurrentIndex(0);
        }
        else
        {
            ui->sw->setCurrentIndex(1);
        }
    });
}


// 设置风格
void MainWindow::SetStyleSheet()
{
    ui->te_title->setStyleSheet("font-size: 20px;");
    ui->te_res->setStyleSheet("font-size: 20px;");
    ui->te_score->setStyleSheet("font-size: 20px;");
    ui->te_answer->setStyleSheet("font-size: 20px;");
    ui->te_a->setStyleSheet("font-size: 20px;");
    ui->te_b->setStyleSheet("font-size: 20px;");
    ui->te_c->setStyleSheet("font-size: 20px;");
    ui->te_d->setStyleSheet("font-size: 20px;");

    ui->rb_a->setStyleSheet("font-size: 20px;");
    ui->rb_b->setStyleSheet("font-size: 20px;");
    ui->rb_c->setStyleSheet("font-size: 20px;");
    ui->rb_d->setStyleSheet("font-size: 20px;");

    ui->cb_a->setStyleSheet("font-size: 20px;");
    ui->cb_b->setStyleSheet("font-size: 20px;");
    ui->cb_c->setStyleSheet("font-size: 20px;");
    ui->cb_d->setStyleSheet("font-size: 20px;");

    ui->rb_y->setStyleSheet("font-size: 20px;");
    ui->rb_n->setStyleSheet("font-size: 20px;");

    ui->lb_title->setStyleSheet("font-size: 20px;");
}


// 加载数据库
void MainWindow::LoadExam()
{
    //题目(title)、答案(res)、分类(cate)、分数(score)和题目数量(num)
    QString title, res, cate;
    int score;
    int num = 0;

    QSqlQuery query;//用于执行数据库查询操作
    if(query.exec("SELECT * FROM exam"))//query对象执行SELECT语句查询exam表中的所有记录。如果查询成功，则进入if语句块
    {
        m_arr.clear();//清空之前存储题目的数组 m_arr

        while (query.next())//遍历查询结果集中的每一条记录
        {
            num++;

            //在循环中逐个获取题目的相关信息
            title = query.value(0).toString();
            res = query.value(1).toString();
            score = query.value(2).toInt();
            cate = query.value(3).toString();

            //根据题目的分类创建对应类型的题目对象，并设置对象的属性
            //将创建的题目对象添加到数组 m_arr 中
            if(cate == "单选")
            {
                ChoiceSingle *c = new ChoiceSingle;

                c->m_title = title;
                c->m_res = res;
                c->m_score = score;

                c->m_a = query.value(4).toString();
                c->m_b = query.value(5).toString();
                c->m_c = query.value(6).toString();
                c->m_d = query.value(7).toString();

                m_arr.append(c);
            }

            if(cate == "多选")
            {
                ChoiceMul *c = new ChoiceMul;

                c->m_title = title;
                c->m_res = res;
                c->m_score = score;

                c->m_a = query.value(4).toString();
                c->m_b = query.value(5).toString();
                c->m_c = query.value(6).toString();
                c->m_d = query.value(7).toString();

                m_arr.append(c);
            }

            if(cate == "判断")
            {
                Judge *j = new Judge;
                j->m_title = title;
                j->m_res = res;
                j->m_score = score;

                m_arr.append(j);
            }

            if(cate == "简答")
            {
                Answer *a = new Answer;
                a->m_title = title;
                a->m_res = res;
                a->m_score = score;

                m_arr.append(a);
            }
        }

        //循环结束后，检查题目数量是否大于0
        //如果是，则弹出一个包含提示信息的消息框（QMessageBox）显示试卷加载成功
        //并调用 ShowList() 函数显示加载后的题目列表
        if(num > 0)
        {
            QMessageBox::information(this, "成功", "试卷加载成功");
            ShowList();
        }
        else
        {
            QMessageBox::critical(this, "错误", "数据库中无试卷");
        }
    }
    else
    {
        QMessageBox::critical(this, "错误", "数据库中无试卷");
    }
}


// 保存到数据库
void MainWindow::SaveExam()
{
    //保存数据库操作语句的字符串 str、执行数据库操作的 QSqlQuery 对象 query
    QString str;
    QSqlQuery query;
    QString a, b, c, d;//用于保存选项的字符串 a、b、c、d

    foreach(Question *p, m_arr)// 循环遍历题目数组 m_arr 中的每个题目对象 p
    {
        //判断当前题目对象的类型
        if(p->Cate() == "单选")
        {
            //如果是单选题，则将当前题目对象转换为 ChoiceSingle 类型的指针 c
            //然后使用arg函数构建插入语句的字符串 str，包括题目标题、答案、分数、分类以及选项内容
            ChoiceSingle *c = dynamic_cast<ChoiceSingle *>(p);
            str = QString("INSERT INTO exam VALUES('%1', '%2', %3, '%4', '%5', '%6', '%7', '%8')").
                    arg(p->m_title).arg(p->m_res).arg(p->m_score).arg(p->Cate()).
                    arg(c->m_a).arg(c->m_b).arg(c->m_c).arg(c->m_d);
        }
        else if(p->Cate() == "多选")
        {
            //如果是多选题，则将当前题目对象转换为 ChoiceMul 类型的指针 c
            //然后使用arg函数构建插入语句的字符串 str，包括题目标题、答案、分数、分类以及选项内容
            ChoiceMul *c = dynamic_cast<ChoiceMul *>(p);
            str = QString("INSERT INTO exam VALUES('%1', '%2', %3, '%4', '%5', '%6', '%7', '%8')").
                    arg(p->m_title).arg(p->m_res).arg(p->m_score).arg(p->Cate()).
                    arg(c->m_a).arg(c->m_b).arg(c->m_c).arg(c->m_d);
        }
        else
        {
            //如果不是单选题或多选题，则构建插入语句的字符串 str，只包括题目标题、答案、分数和分类
            str = QString("INSERT INTO exam(title, res, score, cate) VALUES('%1', '%2', %3, '%4')").
                    arg(p->m_title).arg(p->m_res).arg(p->m_score).arg(p->Cate());
        }
        query.exec(str);//使用query对象执行数据库插入操作，将题目数据存储到exam表中
    }

    // 检查题目数组 m_arr 的大小，如果小于1，表示没有试题，则弹出一个包含提示信息的严重性消息框（QMessageBox）
    // 否则，弹出一个包含成功信息的信息框，显示试卷成功保存至数据库
    if(m_arr.size() < 1)
        QMessageBox::critical(this, "提示", "没有试题");
    else
        QMessageBox::information(this, "成功", "试卷成功保存至数据库");
}


// 创建菜单状态栏
void MainWindow::CreateMenu()
{
    // 设置状态栏
    m_lab = new QLabel("", this);// 创建一个QLabel对象m_lab
    ui->statusbar->addWidget(m_lab);// 将m_lab添加到界面的状态栏中

    m_bar = this->menuBar();// 获取主窗口的菜单栏对象

    //创建菜单
    QMenu * setMenu = m_bar->addMenu("出题");
    QMenu * getMenu = m_bar->addMenu("考试");
    QMenu * helpMenu = m_bar->addMenu("帮助");

    //创建菜单项
    QAction * choiceSingle = setMenu->addAction("出单选题");
    QAction * choiceMul = setMenu->addAction("出多选题");
    QAction * judge = setMenu->addAction("出判断题");
    QAction * answer = setMenu->addAction("出简答题");

    connect(choiceSingle, &QAction::triggered, this, [=]()
    {
        ui->stackedWidget->setCurrentIndex(1);// 设置当前索引为 1，即显示特定页面
        ui->sw->setCurrentIndex(0);// 设置当前索引为 0，即显示特定子页面
        m_addCate = "单选";// 设置添加类别为 "单选"

        ClearArea();// 清空相关区域
        m_lab->setText("单选");// 在状态栏上显示文字 "单选"
        m_idx = -1;     // 选择索引置 -1，表示未选中任何项目
    });
    connect(choiceMul, &QAction::triggered, this, [=]()
    {
        ui->stackedWidget->setCurrentIndex(1);
        ui->sw->setCurrentIndex(0);
        m_addCate = "多选";

        ClearArea();
        m_lab->setText("多选");
        m_idx = -1;     // 选择索引置 -1
    });
    connect(judge, &QAction::triggered, this, [=]()
    {
        ui->stackedWidget->setCurrentIndex(1);
        ui->sw->setCurrentIndex(1);
        m_addCate = "判断";

        ClearArea();
        m_lab->setText("判断");
        m_idx = -1;     // 选择索引置 -1
    });
    connect(answer, &QAction::triggered, this, [=]()
    {
        ui->stackedWidget->setCurrentIndex(1);
        ui->sw->setCurrentIndex(1);
        m_addCate = "简答";

        ClearArea();
        m_lab->setText("简答");
        m_idx = -1;     // 选择索引置 -1
    });

    // 考试菜单
    QAction * beginExam = getMenu->addAction("开始考试");
    QAction * loadExam = getMenu->addAction("加载数据库");
    QAction * saveExam = getMenu->addAction("保存到数据库");
    // 开始考试
    connect(beginExam, &QAction::triggered, this, [=]()
    {
        if(100 != ExamScore())// 保证总分是一百
        {
            QMessageBox::critical(this, "提示", "卷子总分不是100分，请重新核实卷子分值");
            return;
        }

        // 开始考试
        ui->stackedWidget->setCurrentIndex(2); // 设置当前索引为2，即显示特定页面
        m_pos = 0; // 初始化当前题目位置为0
        m_idx = -1;// 初始化选择索引为-1
        m_user.clear();// 清空用户答案容器

        // 初始化作答容器
        for(int i = 0; i < m_arr.size(); i++)
            m_user.append("");

        // 显示题目
        ShowExam();

        m_lab->setText("正在考试");// 在状态栏上显示文字 "正在考试"
    });

    // 加载数据库
    connect(loadExam, &QAction::triggered, this, [=]()
    {
        LoadExam();
    });

    // 保存到数据库
    connect(saveExam, &QAction::triggered, this, [=]()
    {
        SaveExam();
    });


    // 帮助菜单
    QAction * helpExam = helpMenu->addAction("帮助");
    QAction * exit = helpMenu->addAction("退出");

    // 帮助
    connect(helpExam, &QAction::triggered, this, [=]()
    {
        QString str = "1.分值只能是整数\n2.选择题答案要用大写字母 A B C D\n"
                      "3.多选题多个答案要空格间隔\n4.简答题多个关键词之间要空格间隔\n"
                      "5.判断题答案用大写 Y N";
        QMessageBox::information(this, "提示", str);
    });

    // 退出
    connect(exit, &QAction::triggered, this, [=](){ close(); });
}


// 作答动作
void MainWindow::Action()
{
    connect(ui->rb_a, &QRadioButton::clicked, this, [=](){ m_user[m_pos] = "A"; });
    connect(ui->rb_b, &QRadioButton::clicked, this, [=](){ m_user[m_pos] = "B"; });
    connect(ui->rb_c, &QRadioButton::clicked, this, [=](){ m_user[m_pos] = "C"; });
    connect(ui->rb_d, &QRadioButton::clicked, this, [=](){ m_user[m_pos] = "D"; });

    connect(ui->cb_a, &QRadioButton::clicked, this, [=](){ ActionMul(); });
    connect(ui->cb_b, &QRadioButton::clicked, this, [=](){ ActionMul(); });
    connect(ui->cb_c, &QRadioButton::clicked, this, [=](){ ActionMul(); });
    connect(ui->cb_d, &QRadioButton::clicked, this, [=](){ ActionMul(); });

    connect(ui->rb_y, &QRadioButton::clicked, this, [=](){ m_user[m_pos] = "Y"; });
    connect(ui->rb_n, &QRadioButton::clicked, this, [=](){ m_user[m_pos] = "N"; });

    connect(ui->te_answer, &QTextEdit::textChanged, this, [=]()
    {
       m_user[m_pos] = ui->te_answer->toPlainText().trimmed();
    });
}


// 多选作答
void MainWindow::ActionMul()
{
    QString str;
    if(ui->cb_a->isChecked()) str += "A";
    if(ui->cb_b->isChecked()) str += " B";
    if(ui->cb_c->isChecked()) str += " C";
    if(ui->cb_d->isChecked()) str += " D";
    m_user[m_pos] = str.trimmed();//去掉str前后空格，防止B C D答案无法识别
}


// 清空添加区
void MainWindow::ClearArea()
{
    ui->te_title->clear();
    ui->te_res->clear();
    ui->te_score->clear();
    ui->te_a->clear();
    ui->te_b->clear();
    ui->te_c->clear();
    ui->te_d->clear();
}


// 显示列表
void MainWindow::ShowList()
{
    // 清空列表
    ui->lst_q->clear();

    // 遍历题目容器并添加到列表
    foreach(Question *p, m_arr)
    {
        // 创建一个新的列表项，并将题目标题设置为文本内容
        QListWidgetItem *item = new QListWidgetItem(p->m_title);
        // 将列表项添加到 QListWidget 控件中
        ui->lst_q->addItem(item);
    }
}


// 显示考试题目
void MainWindow::ShowExam()
{
    // 控件显示题目
    Question *p = m_arr[m_pos];
    ui->lb_title->setText(p->m_title);

    if(p->Cate() == "单选")
    {
        ChoiceSingle *c = dynamic_cast<ChoiceSingle *>(p);
        ui->rb_a->setText(c->m_a);
        ui->rb_b->setText(c->m_b);
        ui->rb_c->setText(c->m_c);
        ui->rb_d->setText(c->m_d);

        ui->sw_exam->setCurrentIndex(0);

        // 控件显示
        if(m_user[m_pos].isEmpty())
        {
            ui->rb_e->setChecked(true);// 如果用户未作答，则选择默认选项 'rb_e'
        }
        else
        {
            // 根据用户选项设置选中状态
            if(m_user[m_pos] == "A") ui->rb_a->setChecked(true);
            if(m_user[m_pos] == "B") ui->rb_b->setChecked(true);
            if(m_user[m_pos] == "C") ui->rb_c->setChecked(true);
            if(m_user[m_pos] == "D") ui->rb_d->setChecked(true);
        }
    }

    if(p->Cate() == "多选")
    {
        ChoiceMul *c = dynamic_cast<ChoiceMul *>(p);
        ui->cb_a->setText(c->m_a);
        ui->cb_b->setText(c->m_b);
        ui->cb_c->setText(c->m_c);
        ui->cb_d->setText(c->m_d);

        ui->sw_exam->setCurrentIndex(1);

        // 控件显示
        // 将复选框的选中状态重置为未选中
        ui->cb_a->setChecked(false);
        ui->cb_b->setChecked(false);
        ui->cb_c->setChecked(false);
        ui->cb_d->setChecked(false);

        // 根据用户选项设置复选框的选中状态
        if(m_user[m_pos].contains("A")) ui->cb_a->setChecked(true);
        if(m_user[m_pos].contains("B")) ui->cb_b->setChecked(true);
        if(m_user[m_pos].contains("C")) ui->cb_c->setChecked(true);
        if(m_user[m_pos].contains("D")) ui->cb_d->setChecked(true);
    }

    if(p->Cate() == "判断")
    {
        ui->sw_exam->setCurrentIndex(2);// 设置题目切换到判断题界面

        // 控件显示
        // 添加判断题的相关控件显示操作
        if(m_user[m_pos].isEmpty())// 如果用户答案为空
        {
            ui->rb_y->setChecked(false);// 取消选择“是”单选按钮
            ui->rb_n->setChecked(false);// 取消选择“否”单选按钮
        }
        else// 如果用户答案非空
        {
            if(m_user[m_pos] == "Y")// 如果用户答案是"Y"
                ui->rb_y->setChecked(true);// 选中“是”单选按钮
            else if(m_user[m_pos] == "N")// 如果用户答案是"N"
                ui->rb_n->setChecked(true);// 选中“否”单选按钮
            else// 如果用户答案既不是"Y"也不是"N"
                ui->rb_yn->setChecked(true);// 选中“是/否”单选按钮
        }
    }

    if(p->Cate() == "简答")// 如果问题的类型是"简答"
    {
        ui->sw_exam->setCurrentIndex(3); // 设置当前显示的页面为简答题页面

        // 显示用户的答案
        ui->te_answer->setText(m_user[m_pos]);
    }

}


// 计算试卷总分值
int MainWindow::ExamScore()
{
    int sum = 0;
    foreach(Question *p, m_arr)
    {
        sum += p->m_score;// 将每个问题的分值累加到总分值中
    }

    return sum;// 返回试卷总分值
}


// 计算得分
int MainWindow::CalScore()
{
    int sum = 0;

    for(int i = 0; i < m_arr.size(); i++)
    {
        Question *p = m_arr[i];// 获取第i个问题

        // 计算单选和判断得分
        if(p->Cate() == "单选" || p->Cate() == "判断")
        {
            if(p->m_res == m_user[i]) // 如果问题的正确答案与用户的答案相等
                sum += p->m_score;// 加上问题的分值
        }

        // 计算多选题得分
        if(p->Cate() == "多选" )
        {
            QStringList srclst = p->m_res.split(" ");// 将问题的正确答案分割为字符串列表
            QStringList usrlst = m_user[i].split(" ");// 将用户的答案分割为字符串列表
            if(srclst.size() == usrlst.size())// 将用户的答案分割为字符串列表
            {
                int cnt = 0;
                foreach(QString str, srclst)// 遍历问题的选项
                {
                    if(usrlst.contains(str))// 如果用户的答案包含该选项
                        cnt++;
                }

                if(cnt == srclst.size())// 如果计数等于问题的选项数,加上问题的分值
                    sum += p->m_score;
            }
        }

        // 计算简答题得分
        if(p->Cate() == "简答" )
        {
            QStringList srclst = p->m_res.split(" ");// 将问题的关键词分割为字符串列表
            int cnt = 0;

            foreach(auto key, srclst)// 遍历问题的关键词
            {
                if(m_user[i].contains(key)) // 如果用户的答案包含关键词
                    cnt++;
            }
            sum += p->m_score * (cnt * 1.0/srclst.size());// 根据关键词出现的次数计算得分
        }
    }

    return sum;
}


// 增加题目
void MainWindow::on_btn_add_clicked()
{
    // 1、取值
    QString title = ui->te_title->toPlainText().trimmed();
    QString res = ui->te_res->toPlainText().trimmed();
    QString score = ui->te_score->toPlainText().trimmed();

    QString a = ui->te_a->toPlainText().trimmed();
    QString b = ui->te_b->toPlainText().trimmed();
    QString c = ui->te_c->toPlainText().trimmed();
    QString d = ui->te_d->toPlainText().trimmed();

    // 2、判定
    if(title.isEmpty() || res.isEmpty() || score.isEmpty() || score.isEmpty())
    {
        // 如果有任何一个输入框为空，则弹出错误消息框，并返回
        QMessageBox::critical(this, "错误", "不能为空");
        return;
    }

    if(m_addCate == "单选" || m_addCate == "多选")
    {
        if(a.isEmpty() || b.isEmpty() || c.isEmpty() || d.isEmpty())
        {
            // 如果题目类型为单选或多选，并且任何一个选项为空，则弹出错误消息框，并返回
            QMessageBox::critical(this, "错误", "选项不能为空");
            return;
        }
    }

    // 3、增加题目
    if(m_addCate == "单选")
    {
        // 创建单选题对象，并设置题目信息
        ChoiceSingle *p = new ChoiceSingle;
        p->m_title = title;
        p->m_res = res;
        p->m_score = score.toInt();

        // 设置选项信息
        p->m_a = a;
        p->m_b = b;
        p->m_c = c;
        p->m_d = d;

        // 将题目对象添加到题目数组
        m_arr.append(p);
    }
    if(m_addCate == "多选")
    {
        // 创建多选题对象，并设置题目信息
        ChoiceMul *p = new ChoiceMul;
        p->m_title = title;
        p->m_res = res;
        p->m_score = score.toInt();

        // 设置选项信息
        p->m_a = a;
        p->m_b = b;
        p->m_c = c;
        p->m_d = d;

        // 将题目对象添加到题目数组
        m_arr.append(p);
    }
    if(m_addCate == "判断")
    {
        Judge *p = new Judge;
        p->m_title = title;
        p->m_res = res;
        p->m_score = score.toInt();

        m_arr.append(p);
    }
    if(m_addCate == "简答")
    {
        Answer *p = new Answer;
        p->m_title = title;
        p->m_res = res;
        p->m_score = score.toInt();

        m_arr.append(p);
    }

    m_idx = -1;     // 选择索引置 -1

    // 4、更新列表
    ShowList();// 更新题目列表显示
}


// 修改试题
void MainWindow::on_btn_mod_clicked()
{
    if(-1 == m_idx)//检查是否选择了要修改的题目
    {
        QMessageBox::critical(this, "提示", "先选择题目列表中要修改的题目");
        return;
    }

    // 修改
    // 根据用户在界面上输入的内容修改题目的相关属性
    Question *p = m_arr[m_idx];
    p->m_title = ui->te_title->toPlainText().trimmed();
    p->m_res = ui->te_res->toPlainText().trimmed();
    p->m_score = ui->te_score->toPlainText().trimmed().toInt();

    // 如果题目是选择题，则还会修改选项内容
    if(p->Cate().contains("选"))
    {
        Choice *c = dynamic_cast<Choice *>(p);
        c->m_a = ui->te_a->toPlainText().trimmed();
        c->m_b = ui->te_b->toPlainText().trimmed();
        c->m_c = ui->te_c->toPlainText().trimmed();
        c->m_d = ui->te_d->toPlainText().trimmed();
    }

    // 更新题目列表的显示
    ShowList();
}


// 交卷
// 点击"交卷"按钮时，会将考试界面切换回主界面
void MainWindow::on_btn_submit_clicked()
{
    // 考试结束
    ui->stackedWidget->setCurrentIndex(0);

    // 对比提交和答案计算分数
    int total = CalScore();

    // 会弹出消息框显示得分信息
    QMessageBox::information(this, "分数", QString("得分：%1").arg(total));
}


// 上一题
void MainWindow::on_btn_pre_clicked()
{
    // 检查当前题目是否为第一题
    if(m_pos > 0)
    {
        m_pos--;
        ShowExam();
        update();
    }
    else
    {
        // 第一题提示
        QMessageBox::critical(this, "提示", "已经是第一题了");
    }
}


// 下一题
void MainWindow::on_btn_next_clicked()
{
    qDebug() << m_user;

    // 数组越界检查,确保不会越界访问题目列表
    if(m_pos < m_arr.size() - 1)
    {
        m_pos++;//当前题目不是最后一题，则将题目索引m_pos加1

        // 更新考题
        // 调用ShowExam()函数来显示下一题的内容
        ShowExam();
        // 进行界面更新
        update();
    }
    else// 如果当前已经是最后一题
    {
        // 最后一题提示
        QMessageBox::critical(this, "提示", "已经是最后一题了，可以交卷了");
    }

    // 按钮取消
    qDebug() << "m_pos " << m_pos;
    ui->rb_yn->setChecked(true);// 将"是"选项设为默认选中状态
}
